{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# MAGIC-UNet + Fourier Method Comparison and Analysis"
      ],
      "metadata": {
        "id": "2IEh-9nA8BKz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import math\n",
        "import scipy.fft\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib as mpl\n",
        "from skimage.metrics import structural_similarity as ssim\n",
        "import scipy.io as sp\n",
        "from skimage.metrics import peak_signal_noise_ratio as psnr\n",
        "import pickle"
      ],
      "metadata": {
        "id": "Z84SAsRh76bD"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Colab has tensorflow 2.17.1 (as of writing), so we need to intall 2.15"
      ],
      "metadata": {
        "id": "12yoH36WLaFO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install tensorflow==2.15.0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "U1HLmMatKySI",
        "outputId": "91243407-ba42-49be-ac35-3cc0028466d1"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting tensorflow==2.15.0\n",
            "  Downloading tensorflow-2.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.4 kB)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=23.5.26 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (24.12.23)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (0.2.0)\n",
            "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (3.12.1)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (18.1.1)\n",
            "Collecting ml-dtypes~=0.2.0 (from tensorflow==2.15.0)\n",
            "  Downloading ml_dtypes-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (20 kB)\n",
            "Requirement already satisfied: numpy<2.0.0,>=1.23.5 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (1.26.4)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (4.25.5)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (4.12.2)\n",
            "Collecting wrapt<1.15,>=1.11.0 (from tensorflow==2.15.0)\n",
            "  Downloading wrapt-1.14.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.7 kB)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (0.37.1)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow==2.15.0) (1.69.0)\n",
            "Collecting tensorboard<2.16,>=2.15 (from tensorflow==2.15.0)\n",
            "  Downloading tensorboard-2.15.2-py3-none-any.whl.metadata (1.7 kB)\n",
            "Collecting tensorflow-estimator<2.16,>=2.15.0 (from tensorflow==2.15.0)\n",
            "  Downloading tensorflow_estimator-2.15.0-py2.py3-none-any.whl.metadata (1.3 kB)\n",
            "Collecting keras<2.16,>=2.15.0 (from tensorflow==2.15.0)\n",
            "  Downloading keras-2.15.0-py3-none-any.whl.metadata (2.4 kB)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow==2.15.0) (0.45.1)\n",
            "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (2.27.0)\n",
            "Requirement already satisfied: google-auth-oauthlib<2,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (1.2.1)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.7)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (2.32.3)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.1.3)\n",
            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (5.5.0)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (0.4.1)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (4.9)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (1.3.1)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (2024.12.14)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.0.2)\n",
            "Requirement already satisfied: pyasn1<0.7.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (0.6.1)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow==2.15.0) (3.2.2)\n",
            "Downloading tensorflow-2.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (475.2 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m475.2/475.2 MB\u001b[0m \u001b[31m1.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading keras-2.15.0-py3-none-any.whl (1.7 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading ml_dtypes-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.0 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.0/1.0 MB\u001b[0m \u001b[31m36.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading tensorboard-2.15.2-py3-none-any.whl (5.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.5/5.5 MB\u001b[0m \u001b[31m61.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading tensorflow_estimator-2.15.0-py2.py3-none-any.whl (441 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m442.0/442.0 kB\u001b[0m \u001b[31m24.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading wrapt-1.14.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (77 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: wrapt, tensorflow-estimator, ml-dtypes, keras, tensorboard, tensorflow\n",
            "  Attempting uninstall: wrapt\n",
            "    Found existing installation: wrapt 1.17.0\n",
            "    Uninstalling wrapt-1.17.0:\n",
            "      Successfully uninstalled wrapt-1.17.0\n",
            "  Attempting uninstall: ml-dtypes\n",
            "    Found existing installation: ml-dtypes 0.4.1\n",
            "    Uninstalling ml-dtypes-0.4.1:\n",
            "      Successfully uninstalled ml-dtypes-0.4.1\n",
            "  Attempting uninstall: keras\n",
            "    Found existing installation: keras 3.5.0\n",
            "    Uninstalling keras-3.5.0:\n",
            "      Successfully uninstalled keras-3.5.0\n",
            "  Attempting uninstall: tensorboard\n",
            "    Found existing installation: tensorboard 2.17.1\n",
            "    Uninstalling tensorboard-2.17.1:\n",
            "      Successfully uninstalled tensorboard-2.17.1\n",
            "  Attempting uninstall: tensorflow\n",
            "    Found existing installation: tensorflow 2.17.1\n",
            "    Uninstalling tensorflow-2.17.1:\n",
            "      Successfully uninstalled tensorflow-2.17.1\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "tensorstore 0.1.71 requires ml_dtypes>=0.3.1, but you have ml-dtypes 0.2.0 which is incompatible.\n",
            "tf-keras 2.17.0 requires tensorflow<2.18,>=2.17, but you have tensorflow 2.15.0 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0mSuccessfully installed keras-2.15.0 ml-dtypes-0.2.0 tensorboard-2.15.2 tensorflow-2.15.0 tensorflow-estimator-2.15.0 wrapt-1.14.1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "keras",
                  "ml_dtypes",
                  "tensorflow",
                  "wrapt"
                ]
              },
              "id": "f1ca1d6556e44827aa171f2398575ae5"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.17.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z2Ouf6XALr2d",
        "outputId": "cc687148-a398-4d3e-8212-3a3eb4113f6f"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.15.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions"
      ],
      "metadata": {
        "id": "0XmwF3EK8NxT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def dotheFFTsShift(data):\n",
        "    numimages=np.shape(data)[0]\n",
        "    bigger_out=[]\n",
        "    out0=[]\n",
        "    out1=[]\n",
        "    out2=[]\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fftshift(np.fft.fft2(data[i,:,:,0]))\n",
        "        out0.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fftshift(np.fft.fft2(data[i,:,:,1]))\n",
        "        out1.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fftshift(np.fft.fft2(data[i,:,:,2]))\n",
        "        out2.append(temp)\n",
        "    return np.asarray(out0), np.asarray(out1), np.asarray(out2)\n",
        "\n",
        "def dotheiFFTsShift(data):\n",
        "    numimages=np.shape(data)[1]\n",
        "    bigger_out=[]\n",
        "    out0=[]\n",
        "    out1=[]\n",
        "    out2=[]\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.ifft2(np.fft.ifftshift(data[0][i,:,:]))\n",
        "        out0.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.ifft2(np.fft.ifftshift(data[1][i,:,:]))\n",
        "        out1.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.ifft2(np.fft.ifftshift(data[2][i,:,:]))\n",
        "        out2.append(temp)\n",
        "    return np.asarray(out0), np.asarray(out1), np.asarray(out2)\n",
        "\n",
        "def dotheiFFTsJShift(data):\n",
        "    numimages=np.shape(data)[1]\n",
        "    bigger_out=[]\n",
        "    out0=[]\n",
        "    out1=[]\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.ifft2(np.fft.ifftshift(data[0][i,:,:]))\n",
        "        out0.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.ifft2(np.fft.ifftshift(data[1][i,:,:]))\n",
        "        out1.append(temp)\n",
        "    return np.asarray(out0), np.asarray(out1)\n",
        "\n",
        "def dotheFFTsJ(data):\n",
        "    numimages=np.shape(data)[0]\n",
        "    bigger_out=[]\n",
        "    out0=[]\n",
        "    out1=[]\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fft2(data[i,:,:,0])\n",
        "        out0.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fft2(data[i,:,:,1])\n",
        "        out1.append(temp)\n",
        "    return np.asarray(out0), np.asarray(out1)\n",
        "\n",
        "def dotheFFTsJShift(data):\n",
        "    numimages=np.shape(data)[0]\n",
        "    bigger_out=[]\n",
        "    out0=[]\n",
        "    out1=[]\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fftshift(np.fft.fft2(data[i,:,:,0]))\n",
        "        out0.append(temp)\n",
        "    for i in range(numimages):\n",
        "        temp=np.fft.fftshift(np.fft.fft2(data[i,:,:,1]))\n",
        "        out1.append(temp)\n",
        "    return np.asarray(out0), np.asarray(out1)\n",
        "\n",
        "def UNET_normalized_inference(data_in_temp, model):\n",
        "\n",
        "  vect_norm=(data_in_temp[:,:,:,0]**2+data_in_temp[:,:,:,1]**2+data_in_temp[:,:,:,2]**2)**0.5\n",
        "  vect_norm=np.max(vect_norm,axis=1)\n",
        "  vect_norm=np.max(vect_norm,axis=1)\n",
        "\n",
        "  file_size=np.size(vect_norm\n",
        "                    )\n",
        "  for j in range(file_size):\n",
        "\n",
        "      if vect_norm[j]!=0:\n",
        "          data_in_temp[j,:,:,:]=data_in_temp[j,:,:,:]/vect_norm[j]\n",
        "\n",
        "  pred_jx,pred_jy=model.predict(data_in_temp)\n",
        "  data_out_temp=np.zeros([file_size,64,64,2])\n",
        "\n",
        "  for j in range(file_size):\n",
        "\n",
        "      if vect_norm[j]!=0:\n",
        "          data_out_temp[j,:,:,0]=pred_jx[j,:,:,0]*vect_norm[j]*1e11\n",
        "          data_out_temp[j,:,:,1]=pred_jy[j,:,:,0]*vect_norm[j]*1e11\n",
        "\n",
        "  return data_out_temp\n",
        "\n",
        "def blurBs(bx, by, bz, strength):\n",
        "    kmagsquared = kx**2+ky**2\n",
        "    blurfunction=np.exp(-0.25*kmagsquared*strength**2)\n",
        "    return bx*blurfunction, by*blurfunction, bz*blurfunction\n",
        "\n",
        "def lessInfuriatingTensorProduct(twodarray, onedarray):\n",
        "    temp=np.outer(onedarray, twodarray)\n",
        "    out=[]\n",
        "    for i in range(np.size(onedarray)):\n",
        "        out.append(temp[i].reshape((np.shape(twodarray)[0], np.shape(twodarray)[1])))\n",
        "    return np.asarray(out)\n",
        "\n",
        "def fourierb_from_fourierj(jx, jy):\n",
        "    kmag = np.sqrt(kx**2+ky**2)\n",
        "    exponentialargument=lessInfuriatingTensorProduct(kmag, standoff_distances)\n",
        "    scalefactor = (mu0*d)/2\n",
        "    print(np.shape(jy))\n",
        "    bx = scalefactor*np.exp(-exponentialargument)*jy\n",
        "    by = -scalefactor*np.exp(-exponentialargument)*jx\n",
        "    jxjycurlcrossterm=(ky/kmag)*jx-(kx/kmag)*jy\n",
        "    bz = -1j*scalefactor*np.exp(-exponentialargument)*(jxjycurlcrossterm)\n",
        "    return bx, by, bz\n",
        "\n",
        "def fourierj_from_fourierb(bx, by, bz):\n",
        "    kmag = np.sqrt(kx**2+ky**2)\n",
        "    exponentialargument=lessInfuriatingTensorProduct(kmag, standoff_distances)\n",
        "    scalefactor = 2/(mu0*d)\n",
        "\n",
        "    if hw_filter:\n",
        "        hann2D=np.zeros([len(k),len(k)])\n",
        "        for i in range(len(k)):\n",
        "            for j in range(len(k)):\n",
        "\n",
        "                kmag_temp=np.sqrt(k[i]**2+k[j]**2);\n",
        "\n",
        "                if kmag_temp<kmax:\n",
        "                    hann2D[i,j]=0.5*(1+math.cos((math.pi*kmag_temp/kmax)))\n",
        "                else:\n",
        "                    hann2D[i,j]=1\n",
        "\n",
        "        bx=bx*hann2D\n",
        "        by=by*hann2D\n",
        "        bz=bz*hann2D\n",
        "\n",
        "    jx = -scalefactor*np.exp(exponentialargument)*by\n",
        "    jy = scalefactor*np.exp(exponentialargument)*bx\n",
        "    return jx, jy\n",
        "\n",
        "def calculate_ssim_rmse_psnr(validationdata, fourierdata, predictiondata):\n",
        "    ssim_vec_f_x=np.zeros([asize,1])\n",
        "    ssim_vec_f_y=np.zeros_like(ssim_vec_f_x)\n",
        "    ssim_vec_pred_x=np.zeros_like(ssim_vec_f_x)\n",
        "    ssim_vec_pred_y=np.zeros_like(ssim_vec_f_x)\n",
        "    rmse_vec_f_x=np.zeros_like(ssim_vec_f_x)\n",
        "    rmse_vec_f_y=np.zeros_like(ssim_vec_f_x)\n",
        "    rmse_vec_pred_x=np.zeros_like(ssim_vec_f_x)\n",
        "    rmse_vec_pred_y=np.zeros_like(ssim_vec_f_x)\n",
        "    psnr_vec_f_x=np.zeros_like(ssim_vec_f_x)\n",
        "    psnr_vec_f_y=np.zeros_like(ssim_vec_f_x)\n",
        "    psnr_vec_pred_x=np.zeros_like(ssim_vec_f_x)\n",
        "    psnr_vec_pred_y=np.zeros_like(ssim_vec_f_x)\n",
        "\n",
        "    for i in range(asize):\n",
        "        vmax=np.max(abs(validationdata[i,:]))\n",
        "        if vmax==0:\n",
        "            vmax=1e7\n",
        "        vmin=-vmax\n",
        "        ssim_vec_f_x[i,0]=ssim(validationdata[i,:,:,0],fourierdata[i,:,:,0],data_range=2*vmax, multichannel=False)\n",
        "        ssim_vec_f_y[i,0]=ssim(validationdata[i,:,:,1],fourierdata[i,:,:,1],data_range=2*vmax, multichannel=False)\n",
        "        ssim_vec_pred_x[i,0]=ssim(validationdata[i,:,:,0], predictiondata[i,:,:,0],data_range=2*vmax, multichannel=False) #predictiondata[i,:,:,0]\n",
        "        ssim_vec_pred_y[i,0]=ssim(validationdata[i,:,:,1],predictiondata[i,:,:,1],data_range=2*vmax, multichannel=False)\n",
        "\n",
        "        rmse_array_f=np.sqrt(((validationdata[i,:,:,:]-fourierdata[i,:,:,:])/vmax)**2)\n",
        "        rmse_array_pred=np.sqrt(((validationdata[i,:,:,:]-predictiondata[i,:,:,:])/vmax)**2)\n",
        "        rmse_vec_f_x[i]=np.mean(rmse_array_f[:,:,0])\n",
        "        rmse_vec_f_y[i]=np.mean(rmse_array_f[:,:,1])\n",
        "        rmse_vec_pred_x[i]=np.mean(rmse_array_pred[:,:,0])\n",
        "        rmse_vec_pred_y[i]=np.mean(rmse_array_pred[:,:,1])\n",
        "\n",
        "        psnr_vec_f_x[i,0]=psnr(validationdata[i,:,:,0],fourierdata[i,:,:,0],data_range=2*vmax)\n",
        "        psnr_vec_f_y[i,0]=psnr(validationdata[i,:,:,1],fourierdata[i,:,:,1],data_range=2*vmax)\n",
        "        psnr_vec_pred_x[i,0]=psnr(validationdata[i,:,:,0],predictiondata[i,:,:,0],data_range=2*vmax)\n",
        "        psnr_vec_pred_y[i,0]=psnr(validationdata[i,:,:,1],predictiondata[i,:,:,1],data_range=2*vmax)\n",
        "\n",
        "    ssim_val_f_x=np.mean(ssim_vec_f_x)\n",
        "    ssim_val_f_y=np.mean(ssim_vec_f_y)\n",
        "    ssim_val_pred_x=np.mean(ssim_vec_pred_x)\n",
        "    ssim_val_pred_y=np.mean(ssim_vec_pred_y)\n",
        "    ssim_val_f = (ssim_val_f_x + ssim_val_f_y)/2\n",
        "    ssim_val_pred = (ssim_val_pred_x + ssim_val_pred_y)/2\n",
        "\n",
        "    rmse_val_f_x=np.mean(rmse_vec_f_x)\n",
        "    rmse_val_f_y=np.mean(rmse_vec_f_y)\n",
        "    rmse_val_pred_x=np.mean(rmse_vec_pred_x)\n",
        "    rmse_val_pred_y=np.mean(rmse_vec_pred_y)\n",
        "    rmse_val_f=(rmse_val_f_x + rmse_val_f_y)/2\n",
        "    rmse_val_pred=(rmse_val_pred_x + rmse_val_pred_y)/2\n",
        "\n",
        "    psnr_val_f_x=np.mean(filter_inf(psnr_vec_f_x))\n",
        "    psnr_val_f_y=np.mean(filter_inf(psnr_vec_f_y))\n",
        "    psnr_val_pred_x=np.mean(filter_inf(psnr_vec_pred_x))\n",
        "    psnr_val_pred_y=np.mean(filter_inf(psnr_vec_pred_y))\n",
        "    psnr_val_f = (psnr_val_f_x + psnr_val_f_y)/2\n",
        "    psnr_val_pred = (psnr_val_pred_x + psnr_val_pred_y)/2\n",
        "\n",
        "    return [ssim_val_f_x, ssim_val_f_y, ssim_val_pred_x, ssim_val_pred_y, ssim_val_f, ssim_val_pred], \\\n",
        "        [rmse_val_f_x, rmse_val_f_y, rmse_val_pred_x, rmse_val_pred_y, rmse_val_f, rmse_val_pred], \\\n",
        "            [psnr_val_f_x, psnr_val_f_y, psnr_val_pred_x, psnr_val_pred_y, psnr_val_f, psnr_val_pred]\n",
        "\n",
        "def filter_inf(mat):\n",
        "    mat=np.asarray(mat)\n",
        "    return mat[np.isfinite(mat)]"
      ],
      "metadata": {
        "id": "SuvWxETR78G3"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## If running in colab, mount drive to access files"
      ],
      "metadata": {
        "id": "04wad1VZ94Ui"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "%cd /content/drive/MyDrive/Magnetic Inverse/"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NEqiSd6S9164",
        "outputId": "22b7966e-8c52-47a7-c32d-487f250336cb"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "/content/drive/MyDrive/Magnetic Inverse\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## load data & trained model"
      ],
      "metadata": {
        "id": "jNuwKg2MI-U9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## noise settings (data provided is noise free, it must be added for testing) ##\n",
        "\n",
        "noise=True\n",
        "mean_noise=0.2 #ratio of std of additive noise to max field amplitude\n",
        "\n",
        "# Load Validation Data\n",
        "data_file_in='Data/InDistributionVal/validation_64x64_50um_Bxyz.npy'\n",
        "data_file_out='Data/InDistributionVal/validation_64x64_50um_Jxy.npy'\n",
        "\n",
        "data_in=np.load(data_file_in)\n",
        "data_out=np.load(data_file_out)\n",
        "J_mag=np.sqrt(data_out[:,:,:,0]**2+data_out[:,:,:,1]**2)\n",
        "\n",
        "#for faster testing\n",
        "data_in=data_in[:16,:]\n",
        "data_out=data_out[:16,:]\n",
        "\n",
        "pixel_number_x = np.shape(data_in)[1]\n",
        "asize=np.shape(data_in)[0]\n",
        "\n",
        "##add noise\n",
        "\n",
        "data_in_copy=np.copy(data_in)\n",
        "\n",
        "if noise:\n",
        "  vect_norm=np.sqrt(data_in[:,:,:,0]**2+data_in[:,:,:,1]**2+data_in[:,:,:,2]**2)\n",
        "  vect_norm=np.max(vect_norm,axis=1)\n",
        "  vect_norm=np.max(vect_norm,axis=1)\n",
        "\n",
        "  for j in range(asize):\n",
        "\n",
        "    np.random.seed(j);\n",
        "    noise_array = np.random.normal(0,mean_noise*vect_norm[j],np.shape(data_in[0,:,:,:]))\n",
        "    data_in_copy[j,:]=data_in_copy[j,:]+noise_array\n",
        "\n"
      ],
      "metadata": {
        "id": "kbTX_61aI8CF"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Load Trained Model\n",
        "exp_name='MAGIC_UNet_64x64_50um'\n",
        "model_dir=exp_name+'/checkpoint'\n",
        "model=tf.keras.models.load_model(model_dir)"
      ],
      "metadata": {
        "id": "r4g00759XzXZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Parameters for Fourier Method\n",
        "\n",
        "Hann function: [link](https://en.wikipedia.org/wiki/Hann_function)\n",
        "\n",
        "Note that the values for `kmax` and `gauss_filt_strength` were chosen by running a 2d optimization script to find the values than maximized SSIM for the Fourier Method at noise = 0.2\n",
        "\n"
      ],
      "metadata": {
        "id": "6rR5ZfHmVx74"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#### parameters used in Fourier Inversion (not needed for network) ####\n",
        "\n",
        "#permeability of free space\n",
        "mu0 = 1.25663706212e-6\n",
        "\n",
        "d = 14e-6 #vertical depth of current plane\n",
        "device_x_dimension=2e-3 #linear size of field of view (meters)\n",
        "hw_filter=True #turn Hann window function on/off\n",
        "\n",
        "noise=True #turn additive Gaussian noise on/off\n",
        "mean_noises=list(np.linspace(0,1,21)) #list of noise levels to test\n",
        "#levels represent std relative to max magnetic field pixel\n",
        "\n",
        "#**** 50 micron network ****\n",
        "\n",
        "z=50e-6 #average standoff distance\n",
        "#alternatively, you can use vector of exact values here\n",
        "kmax=90147.05882352941 #controls behavior of Hann function\n",
        "gauss_filt_strength=0.00012147058823529412 #Gaussian filter to reduce aliasing\n",
        "\n",
        "#****500 micron network****\n",
        "\n",
        "#z=500e-6\n",
        "#kmax=3029.1428571428573\n",
        "#gauss_filt_strength=0.00041142857142857143 #Gaussian filter to reduce aliasing\n",
        "\n",
        "\n",
        "# Set up Fourier space\n",
        "dx = device_x_dimension/pixel_number_x\n",
        "dkx = 2*np.pi/(pixel_number_x*dx)\n",
        "k = np.arange(-dkx*pixel_number_x/2, dkx*pixel_number_x/2, dkx)\n",
        "k = np.where(np.abs(k)<1e-9,1e-9,k) #prevent weird behavior from k near 0\n",
        "kx, ky = np.meshgrid(k, k)"
      ],
      "metadata": {
        "id": "yOuw2AZ4TkJq"
      },
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fourier Inversion"
      ],
      "metadata": {
        "id": "6GY2WgpuUnrj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "standoff_distances=z*np.ones(asize)\n",
        "\n",
        "bx_fourier_shifted, by_fourier_shifted, bz_fourier_shifted=dotheFFTsShift(data_in)\n",
        "bx_fourier_shifted_blurred, by_fourier_shifted_blurred, bz_fourier_shifted_blurred = blurBs(bx_fourier_shifted, by_fourier_shifted, bz_fourier_shifted, gauss_filt_strength)\n",
        "\n",
        "jx_fourier, jy_fourier = fourierj_from_fourierb(bx_fourier_shifted_blurred, by_fourier_shifted_blurred, bz_fourier_shifted_blurred)\n",
        "Jx_simulated, Jy_simulated = dotheiFFTsJShift([jx_fourier, jy_fourier])\n",
        "\n",
        "data_out_fourier=np.zeros([asize,pixel_number_x,pixel_number_x,2])\n",
        "data_out_fourier[:,:,:,0]=np.real(Jx_simulated)\n",
        "data_out_fourier[:,:,:,1]=np.real(Jy_simulated)\n",
        "J_mag_fourier=np.sqrt(data_out_fourier[:,:,:,0]**2+data_out_fourier[:,:,:,1]**2)"
      ],
      "metadata": {
        "id": "3BHUYE48UnFP"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## MAGIC-UNet Prediction"
      ],
      "metadata": {
        "id": "5oVbN3FpWPyN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data_out_pred=UNET_normalized_inference(data_in_copy,model);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "41_1lguDV97s",
        "outputId": "c2858cf8-f5c8-4b44-d835-d3b2e778ab55"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 4s 4s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plot Predictions"
      ],
      "metadata": {
        "id": "EbguvbLwX8mI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#set coloramps\n",
        "cmap=mpl.cm.PuOr #magnetic field\n",
        "cmap2=mpl.cm.RdBu #current densities\n",
        "\n",
        "i=8 #configuration to be plotted\n",
        "\n",
        "vmax=np.max(np.linalg.norm(data_out[i,:,:,:],axis=2))\n",
        "vmaxb=np.max(np.linalg.norm(data_in[i,:,:,:],axis=2))\n",
        "vmaxc=np.max(np.linalg.norm(data_out_fourier[i,:,:,:],axis=2))\n",
        "vmaxd=np.max(np.linalg.norm(data_out_pred[i,:,:,:],axis=2))\n",
        "\n",
        "##magnetic field\n",
        "\n",
        "fig, axes=plt.subplots(4,3,figsize=(15,15))\n",
        "a00=axes[0,0].imshow(data_in[i,...,0],vmin=-vmaxb,vmax=vmaxb,cmap=cmap)\n",
        "axes[0,0].set_title('$B_x$')\n",
        "axes[0,0].get_xaxis().set_visible(True); axes[0,0].get_yaxis().set_visible(False)\n",
        "fig.colorbar(a00,ax=axes[0,0])\n",
        "\n",
        "a01=axes[0,1].imshow(data_in[i,...,1],vmin=-vmaxb,vmax=vmaxb,cmap=cmap)\n",
        "axes[0,1].set_title('$B_y$')\n",
        "axes[0,1].get_xaxis().set_visible(True); axes[0,1].get_yaxis().set_visible(False)\n",
        "fig.colorbar(a01,ax=axes[0,1])\n",
        "\n",
        "a02=axes[0,2].imshow(data_in[i,...,2],vmin=-vmaxb,vmax=vmaxb,cmap=cmap)\n",
        "axes[0,2].set_title('$B_z$')\n",
        "fig.colorbar(a02,ax=axes[0,2])\n",
        "axes[0,2].get_xaxis().set_visible(True); axes[0,2].get_yaxis().set_visible(False)\n",
        "\n",
        "## Fourier Method Predictions\n",
        "\n",
        "a10=axes[1,0].imshow(data_out_fourier[i,:,:,0],cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[1,0].set_title('Jx, Fourier ')\n",
        "fig.colorbar(a10,ax=axes[1,0])\n",
        "axes[1,0].get_xaxis().set_visible(True); axes[1,0].get_yaxis().set_visible(True)\n",
        "\n",
        "a11=axes[1,1].imshow(data_out_fourier[i,:,:,1],cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[1,1].set_title('Jy, Fourier ')\n",
        "fig.colorbar(a11,ax=axes[1,1])\n",
        "axes[1,1].get_xaxis().set_visible(True); axes[1,1].get_yaxis().set_visible(True)\n",
        "\n",
        "a12=axes[1,2].imshow(np.linalg.norm(data_out_fourier[i,:,:,:],axis=2), cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[1,2].set_title('Mag J, Fourier ')\n",
        "fig.colorbar(a12,ax=axes[1,2])\n",
        "axes[1,2].get_xaxis().set_visible(True); axes[1,2].get_yaxis().set_visible(True)\n",
        "\n",
        "## Ground Truth\n",
        "\n",
        "a20=axes[2,0].imshow(data_out[i,:,:,0],cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[2,0].set_title('Jx, Ground Truth ')\n",
        "fig.colorbar(a20,ax=axes[2,0])\n",
        "axes[2,0].get_xaxis().set_visible(True); axes[2,0].get_yaxis().set_visible(True)\n",
        "\n",
        "a21=axes[2,1].imshow(data_out[i,:,:,1],cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[2,1].set_title('Jy, Ground Truth ')\n",
        "fig.colorbar(a21,ax=axes[2,1])\n",
        "axes[2,1].get_xaxis().set_visible(True); axes[2,1].get_yaxis().set_visible(True)\n",
        "\n",
        "a22=axes[2,2].imshow(np.linalg.norm(data_out[i,:,:,:],axis=2), cmap2,vmin=-vmax,vmax=vmax)\n",
        "axes[2,2].set_title('Mag J, Ground Truth ')\n",
        "fig.colorbar(a22,ax=axes[2,2])\n",
        "axes[2,2].get_xaxis().set_visible(True); axes[2,2].get_yaxis().set_visible(True)\n",
        "\n",
        "## MAGIC-UNet Predictions\n",
        "\n",
        "a30=axes[3,0].imshow(data_out_pred[i,:,:,0],cmap2,vmin=-vmaxd,vmax=vmaxd)\n",
        "axes[3,0].set_title('J,x ML')\n",
        "fig.colorbar(a30,ax=axes[3,0])\n",
        "axes[3,0].get_xaxis().set_visible(True); axes[3,0].get_yaxis().set_visible(True)\n",
        "\n",
        "a31=axes[3,1].imshow(data_out_pred[i,:,:,1],cmap2,vmin=-vmaxd,vmax=vmaxd)\n",
        "axes[3,1].set_title('Jy, ML')\n",
        "fig.colorbar(a31,ax=axes[3,1])\n",
        "axes[3,1].get_xaxis().set_visible(True); axes[3,1].get_yaxis().set_visible(True)\n",
        "\n",
        "a32=axes[3,2].imshow(np.linalg.norm(data_out_pred[i,:,:,:],axis=2), cmap2,vmin=-vmaxd,vmax=vmaxd)\n",
        "axes[3,2].set_title('ML J mag')\n",
        "fig.colorbar(a32,ax=axes[3,2])\n",
        "axes[3,2].get_xaxis().set_visible(True); axes[3,2].get_yaxis().set_visible(True)\n",
        "\n",
        "fig.suptitle('ML vs Fourier Inverse Standard Validation, Index= '+str(i))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "CcapD1YxXAbM",
        "outputId": "ea2b40f8-9714-4009-8e30-2b7fb93407cf"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0.98, 'ML vs Fourier Inverse Standard Validation, Index= 8')"
            ]
          },
          "metadata": {},
          "execution_count": 55
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 24 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Quantitative Analysis"
      ],
      "metadata": {
        "id": "euJioQgFOY4F"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A0mZgAHr7Tba",
        "outputId": "fb2e5fa1-3d83-407f-dbc4-84bb6c05db95"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Noise Level=0.00\n",
            "1/1 [==============================] - 4s 4s/step\n",
            " ssim_Fourier=0.793,          ssim_val_UNET=0.995\n",
            " rmse_Fourier=0.041,          rmse_val_UNET=0.005\n",
            " psnr_Fourier=28.255,          psnr_val_UNET=42.036\n",
            "Noise Level=0.20\n",
            "1/1 [==============================] - 3s 3s/step\n",
            " ssim_Fourier=0.624,          ssim_val_UNET=0.982\n",
            " rmse_Fourier=0.050,          rmse_val_UNET=0.009\n",
            " psnr_Fourier=27.634,          psnr_val_UNET=37.074\n",
            "Noise Level=0.40\n",
            "1/1 [==============================] - 5s 5s/step\n",
            " ssim_Fourier=0.445,          ssim_val_UNET=0.969\n",
            " rmse_Fourier=0.061,          rmse_val_UNET=0.013\n",
            " psnr_Fourier=26.617,          psnr_val_UNET=34.357\n",
            "Noise Level=0.60\n",
            "1/1 [==============================] - 3s 3s/step\n",
            " ssim_Fourier=0.326,          ssim_val_UNET=0.952\n",
            " rmse_Fourier=0.073,          rmse_val_UNET=0.016\n",
            " psnr_Fourier=25.582,          psnr_val_UNET=32.833\n",
            "Noise Level=0.80\n",
            "1/1 [==============================] - 3s 3s/step\n",
            " ssim_Fourier=0.246,          ssim_val_UNET=0.937\n",
            " rmse_Fourier=0.085,          rmse_val_UNET=0.018\n",
            " psnr_Fourier=24.588,          psnr_val_UNET=31.746\n",
            "Noise Level=1.00\n",
            "1/1 [==============================] - 5s 5s/step\n",
            " ssim_Fourier=0.192,          ssim_val_UNET=0.919\n",
            " rmse_Fourier=0.098,          rmse_val_UNET=0.021\n",
            " psnr_Fourier=23.652,          psnr_val_UNET=30.701\n"
          ]
        }
      ],
      "source": [
        "mean_noises=list(np.linspace(0,1,6))\n",
        "\n",
        "for important_number in range(len(mean_noises)):\n",
        "    print(f'Noise Level={mean_noises[important_number]:.2f}')\n",
        "\n",
        "    standoff_distances=z*np.ones(asize)\n",
        "    data_in_copy=np.copy(data_in)\n",
        "\n",
        "\n",
        "    if noise:\n",
        "        vect_norm=np.sqrt(data_in[:,:,:,0]**2+data_in[:,:,:,1]**2+data_in[:,:,:,2]**2)\n",
        "        vect_norm=np.max(vect_norm,axis=1)\n",
        "        vect_norm=np.max(vect_norm,axis=1)\n",
        "\n",
        "        for j in range(asize):\n",
        "\n",
        "            np.random.seed(j);\n",
        "            noise_array = np.random.normal(0,mean_noises[important_number]*vect_norm[j],np.shape(data_in[0,:,:,:]))\n",
        "            data_in_copy[j,:]=data_in_copy[j,:]+noise_array\n",
        "\n",
        "    #--------------------------------------------\n",
        "\n",
        "    bx_fourier_shifted, by_fourier_shifted, bz_fourier_shifted=dotheFFTsShift(data_in_copy)\n",
        "    bx_fourier_shifted_blurred, by_fourier_shifted_blurred, bz_fourier_shifted_blurred = blurBs(bx_fourier_shifted, by_fourier_shifted, bz_fourier_shifted, gauss_filt_strength)\n",
        "\n",
        "    jx_fourier, jy_fourier = fourierj_from_fourierb(bx_fourier_shifted_blurred, by_fourier_shifted_blurred, bz_fourier_shifted_blurred)\n",
        "    Jx_simulated, Jy_simulated = dotheiFFTsJShift([jx_fourier, jy_fourier])\n",
        "\n",
        "    data_out_fourier=np.zeros([asize,pixel_number_x,pixel_number_x,2])\n",
        "    data_out_fourier[:,:,:,0]=np.real(Jx_simulated)\n",
        "    data_out_fourier[:,:,:,1]=np.real(Jy_simulated)\n",
        "\n",
        "    data_out_pred=UNET_normalized_inference(data_in_copy,model);\n",
        "\n",
        "    ssimdata, rmsedata, psnrdata = calculate_ssim_rmse_psnr(data_out, data_out_fourier, data_out_pred)\n",
        "    noise_data[important_number]={'ssimdata': ssimdata, 'rmsedata': rmsedata, 'psnrdata': psnrdata}\n",
        "    print(f' ssim_Fourier={ssimdata[4]:.3f},          ssim_val_UNET={ssimdata[5]:.3f}')\n",
        "    print(f' rmse_Fourier={rmsedata[4]:.3f},          rmse_val_UNET={rmsedata[5]:.3f}')\n",
        "    print(f' psnr_Fourier={psnrdata[4]:.3f},          psnr_val_UNET={psnrdata[5]:.3f}')\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Save quantitative info"
      ],
      "metadata": {
        "id": "jevxI4jMcyXt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the dictionary as a pickle file\n",
        "with open(\"quant_data.pkl\", \"wb\") as file:\n",
        "  pickle.dump(noise_data, file)\n",
        "\n",
        "# plain text version (optional)\n",
        "\n",
        "with open(\"data.txt\", \"w\") as file:\n",
        "  for key, value in noise_data.items():\n",
        "      file.write(f\"{key}: {value}\\n\")"
      ],
      "metadata": {
        "id": "aqbD9Kd9bwSj"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Reload previous quantitative data"
      ],
      "metadata": {
        "id": "OEZcD62xc5i1"
      }
    }
  ]
}